/**
 * 基础数据共享服务
 * 提供组织架构、用户信息等基础数据服务
 */
const AppUtil = require('../../../../framework/core/app_util');
const AppError = require('../../../../framework/core/app_error');
const UserModel = require('../config/models_config').user_model;
const DeptModel = require('../config/models_config').dept_model;

// 缓存配置
const CACHE_TIMEOUT = 5 * 60 * 1000; // 缓存有效期5分钟
const cacheData = {
  users: {
    data: null,
    lastUpdate: 0
  },
  depts: {
    data: null,
    lastUpdate: 0
  }
};

/**
 * 基础数据服务类
 */
class BaseDataService {
  /**
   * 获取所有用户列表（带缓存）
   * @param {Boolean} forceRefresh 是否强制刷新缓存
   * @returns {Promise<Array>} 用户列表
   */
  async getAllUsers(forceRefresh = false) {
    // 检查缓存是否有效
    const now = Date.now();
    if (!forceRefresh && 
        cacheData.users.data && 
        (now - cacheData.users.lastUpdate) < CACHE_TIMEOUT) {
      console.log('[BaseDataService] 从缓存获取用户列表');
      return cacheData.users.data;
    }
    
    // 缓存失效，重新获取数据
    console.log('[BaseDataService] 刷新用户列表缓存');
    try {
      // 从数据库获取用户列表并加工数据
      const userModel = new UserModel();
      const userList = await userModel.getAllUsers({});
      
      // 数据脱敏：移除敏感字段
      const safeUsers = userList.map(user => ({
        _id: user._id,
        name: user.name,
        avatar: user.avatar,
        deptId: user.deptId,
        deptName: user.deptName,
        mobile: user.mobile,
        email: user.email,
        status: user.status
      }));
      
      // 更新缓存
      cacheData.users = {
        data: safeUsers,
        lastUpdate: now
      };
      
      return safeUsers;
    } catch (err) {
      console.error('[BaseDataService] 获取用户列表失败:', err);
      throw new AppError('获取用户列表失败', 10001);
    }
  }
  
  /**
   * 获取所有部门（带缓存）
   * @param {Boolean} forceRefresh 是否强制刷新缓存
   * @returns {Promise<Array>} 部门列表
   */
  async getAllDepts(forceRefresh = false) {
    // 检查缓存是否有效
    const now = Date.now();
    if (!forceRefresh && 
        cacheData.depts.data && 
        (now - cacheData.depts.lastUpdate) < CACHE_TIMEOUT) {
      console.log('[BaseDataService] 从缓存获取部门列表');
      return cacheData.depts.data;
    }
    
    // 缓存失效，重新获取数据
    console.log('[BaseDataService] 刷新部门列表缓存');
    try {
      const deptModel = new DeptModel();
      const deptList = await deptModel.getAllDepts({});
      
      // 更新缓存
      cacheData.depts = {
        data: deptList,
        lastUpdate: now
      };
      
      return deptList;
    } catch (err) {
      console.error('[BaseDataService] 获取部门列表失败:', err);
      throw new AppError('获取部门列表失败', 10002);
    }
  }
  
  /**
   * 根据ID获取用户信息
   * @param {String} userId 用户ID
   * @returns {Promise<Object>} 用户信息
   */
  async getUserById(userId) {
    if (!userId) {
      throw new AppError('用户ID不能为空', 10003);
    }
    
    // 先尝试从缓存获取
    const users = await this.getAllUsers();
    const user = users.find(u => u._id === userId);
    
    if (user) {
      return user;
    }
    
    // 缓存中没有，单独查询
    console.log('[BaseDataService] 从数据库查询单个用户');
    try {
      const userModel = new UserModel();
      const userData = await userModel.getUserById(userId);
      
      if (!userData) {
        throw new AppError('用户不存在', 10004);
      }
      
      // 数据脱敏
      return {
        _id: userData._id,
        name: userData.name,
        avatar: userData.avatar,
        deptId: userData.deptId,
        deptName: userData.deptName,
        mobile: userData.mobile,
        email: userData.email,
        status: userData.status
      };
    } catch (err) {
      console.error('[BaseDataService] 获取用户信息失败:', err);
      throw new AppError('获取用户信息失败', 10005);
    }
  }
  
  /**
   * 获取用户简要信息（头像、姓名）批量接口
   * @param {Array} userIds 用户ID列表
   * @returns {Promise<Object>} {userId: {name, avatar}}
   */
  async getUserBriefBatch(userIds) {
    if (!Array.isArray(userIds) || userIds.length === 0) {
      return {};
    }
    
    // 去重
    const uniqueIds = [...new Set(userIds)];
    
    // 获取所有用户
    const users = await this.getAllUsers();
    
    // 构建结果Map
    const result = {};
    for (const id of uniqueIds) {
      const user = users.find(u => u._id === id);
      if (user) {
        result[id] = {
          name: user.name,
          avatar: user.avatar
        };
      }
    }
    
    return result;
  }
  
  /**
   * 清除缓存
   */
  clearCache() {
    cacheData.users.data = null;
    cacheData.users.lastUpdate = 0;
    cacheData.depts.data = null;
    cacheData.depts.lastUpdate = 0;
    console.log('[BaseDataService] 缓存已清除');
  }
}

module.exports = new BaseDataService(); 